Termination of the given ITRSProblem could successfully be proven:
↳ ITRS
↳ ITRStoIDPProof
ITRS problem:
The following domains are used:
z
The TRS R consists of the following rules:
eval(x, y) → Cond_eval1(&&(>@z(x, 0@z), >@z(y, 0@z)), x, y)
Cond_eval1(TRUE, x, y) → eval(-@z(x, 1@z), x)
eval(x, y) → Cond_eval(&&(>@z(x, 0@z), >@z(y, 0@z)), x, y)
Cond_eval(TRUE, x, y) → eval(-@z(y, 2@z), +@z(x, 1@z))
The set Q consists of the following terms:
eval(x0, x1)
Cond_eval1(TRUE, x0, x1)
Cond_eval(TRUE, x0, x1)
Added dependency pairs
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
I DP problem:
The following domains are used:
z
The ITRS R consists of the following rules:
eval(x, y) → Cond_eval1(&&(>@z(x, 0@z), >@z(y, 0@z)), x, y)
Cond_eval1(TRUE, x, y) → eval(-@z(x, 1@z), x)
eval(x, y) → Cond_eval(&&(>@z(x, 0@z), >@z(y, 0@z)), x, y)
Cond_eval(TRUE, x, y) → eval(-@z(y, 2@z), +@z(x, 1@z))
The integer pair graph contains the following rules and edges:
(0): COND_EVAL(TRUE, x[0], y[0]) → EVAL(-@z(y[0], 2@z), +@z(x[0], 1@z))
(1): COND_EVAL1(TRUE, x[1], y[1]) → EVAL(-@z(x[1], 1@z), x[1])
(2): EVAL(x[2], y[2]) → COND_EVAL(&&(>@z(x[2], 0@z), >@z(y[2], 0@z)), x[2], y[2])
(3): EVAL(x[3], y[3]) → COND_EVAL1(&&(>@z(x[3], 0@z), >@z(y[3], 0@z)), x[3], y[3])
(0) -> (2), if ((+@z(x[0], 1@z) →* y[2])∧(-@z(y[0], 2@z) →* x[2]))
(0) -> (3), if ((+@z(x[0], 1@z) →* y[3])∧(-@z(y[0], 2@z) →* x[3]))
(1) -> (2), if ((x[1] →* y[2])∧(-@z(x[1], 1@z) →* x[2]))
(1) -> (3), if ((x[1] →* y[3])∧(-@z(x[1], 1@z) →* x[3]))
(2) -> (0), if ((x[2] →* x[0])∧(y[2] →* y[0])∧(&&(>@z(x[2], 0@z), >@z(y[2], 0@z)) →* TRUE))
(3) -> (1), if ((x[3] →* x[1])∧(y[3] →* y[1])∧(&&(>@z(x[3], 0@z), >@z(y[3], 0@z)) →* TRUE))
The set Q consists of the following terms:
eval(x0, x1)
Cond_eval1(TRUE, x0, x1)
Cond_eval(TRUE, x0, x1)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
I DP problem:
The following domains are used:
z
R is empty.
The integer pair graph contains the following rules and edges:
(0): COND_EVAL(TRUE, x[0], y[0]) → EVAL(-@z(y[0], 2@z), +@z(x[0], 1@z))
(1): COND_EVAL1(TRUE, x[1], y[1]) → EVAL(-@z(x[1], 1@z), x[1])
(2): EVAL(x[2], y[2]) → COND_EVAL(&&(>@z(x[2], 0@z), >@z(y[2], 0@z)), x[2], y[2])
(3): EVAL(x[3], y[3]) → COND_EVAL1(&&(>@z(x[3], 0@z), >@z(y[3], 0@z)), x[3], y[3])
(0) -> (2), if ((+@z(x[0], 1@z) →* y[2])∧(-@z(y[0], 2@z) →* x[2]))
(0) -> (3), if ((+@z(x[0], 1@z) →* y[3])∧(-@z(y[0], 2@z) →* x[3]))
(1) -> (2), if ((x[1] →* y[2])∧(-@z(x[1], 1@z) →* x[2]))
(1) -> (3), if ((x[1] →* y[3])∧(-@z(x[1], 1@z) →* x[3]))
(2) -> (0), if ((x[2] →* x[0])∧(y[2] →* y[0])∧(&&(>@z(x[2], 0@z), >@z(y[2], 0@z)) →* TRUE))
(3) -> (1), if ((x[3] →* x[1])∧(y[3] →* y[1])∧(&&(>@z(x[3], 0@z), >@z(y[3], 0@z)) →* TRUE))
The set Q consists of the following terms:
eval(x0, x1)
Cond_eval1(TRUE, x0, x1)
Cond_eval(TRUE, x0, x1)
Represented integers and predefined function symbols by Terms
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(x[2], y[2]) → COND_EVAL(and(greater_int(x[2], pos(0)), greater_int(y[2], pos(0))), x[2], y[2])
EVAL(x[3], y[3]) → COND_EVAL1(and(greater_int(x[3], pos(0)), greater_int(y[3], pos(0))), x[3], y[3])
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), neg(y)) → minus_nat(y, x)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
minus_int(pos(x), neg(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(neg(x), pos(y)) → minus_nat(y, x)
plus_int(neg(x), neg(y)) → neg(plus_nat(x, y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
The set Q consists of the following terms:
eval(x0, x1)
Cond_eval1(true, x0, x1)
Cond_eval(true, x0, x1)
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(x[2], y[2]) → COND_EVAL(and(greater_int(x[2], pos(0)), greater_int(y[2], pos(0))), x[2], y[2])
EVAL(x[3], y[3]) → COND_EVAL1(and(greater_int(x[3], pos(0)), greater_int(y[3], pos(0))), x[3], y[3])
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
eval(x0, x1)
Cond_eval1(true, x0, x1)
Cond_eval(true, x0, x1)
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
eval(x0, x1)
Cond_eval1(true, x0, x1)
Cond_eval(true, x0, x1)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(x[2], y[2]) → COND_EVAL(and(greater_int(x[2], pos(0)), greater_int(y[2], pos(0))), x[2], y[2])
EVAL(x[3], y[3]) → COND_EVAL1(and(greater_int(x[3], pos(0)), greater_int(y[3], pos(0))), x[3], y[3])
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(x[2], y[2]) → COND_EVAL(and(greater_int(x[2], pos(0)), greater_int(y[2], pos(0))), x[2], y[2]) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(s(x0)), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(x[3], y[3]) → COND_EVAL1(and(greater_int(x[3], pos(0)), greater_int(y[3], pos(0))), x[3], y[3])
EVAL(neg(s(x0)), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(x[3], y[3]) → COND_EVAL1(and(greater_int(x[3], pos(0)), greater_int(y[3], pos(0))), x[3], y[3]) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(s(x0)), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(neg(s(x0)), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(s(y0)), pos(0)) → COND_EVAL(and(false, false), neg(s(y0)), pos(0))
EVAL(neg(s(y0)), neg(s(x0))) → COND_EVAL(and(false, false), neg(s(y0)), neg(s(x0)))
EVAL(neg(s(y0)), pos(s(x0))) → COND_EVAL(and(false, true), neg(s(y0)), pos(s(x0)))
EVAL(neg(s(y0)), neg(0)) → COND_EVAL(and(false, false), neg(s(y0)), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(neg(s(y0)), pos(0)) → COND_EVAL(and(false, false), neg(s(y0)), pos(0))
EVAL(neg(s(y0)), neg(s(x0))) → COND_EVAL(and(false, false), neg(s(y0)), neg(s(x0)))
EVAL(neg(s(y0)), pos(s(x0))) → COND_EVAL(and(false, true), neg(s(y0)), pos(s(x0)))
EVAL(neg(s(y0)), neg(0)) → COND_EVAL(and(false, false), neg(s(y0)), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, neg(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(0), neg(s(y1))) → COND_EVAL(and(false, false), pos(0), neg(s(y1)))
EVAL(neg(s(x0)), neg(s(y1))) → COND_EVAL(and(false, false), neg(s(x0)), neg(s(y1)))
EVAL(pos(s(x0)), neg(s(y1))) → COND_EVAL(and(true, false), pos(s(x0)), neg(s(y1)))
EVAL(neg(0), neg(s(y1))) → COND_EVAL(and(false, false), neg(0), neg(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(0), neg(s(y1))) → COND_EVAL(and(false, false), pos(0), neg(s(y1)))
EVAL(neg(s(x0)), neg(s(y1))) → COND_EVAL(and(false, false), neg(s(x0)), neg(s(y1)))
EVAL(pos(s(x0)), neg(s(y1))) → COND_EVAL(and(true, false), pos(s(x0)), neg(s(y1)))
EVAL(neg(0), neg(s(y1))) → COND_EVAL(and(false, false), neg(0), neg(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1)
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(neg(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), neg(0), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(0), pos(0)) → COND_EVAL(and(false, false), neg(0), pos(0))
EVAL(neg(0), neg(s(x0))) → COND_EVAL(and(false, false), neg(0), neg(s(x0)))
EVAL(neg(0), pos(s(x0))) → COND_EVAL(and(false, true), neg(0), pos(s(x0)))
EVAL(neg(0), neg(0)) → COND_EVAL(and(false, false), neg(0), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(neg(0), pos(0)) → COND_EVAL(and(false, false), neg(0), pos(0))
EVAL(neg(0), neg(s(x0))) → COND_EVAL(and(false, false), neg(0), neg(s(x0)))
EVAL(neg(0), pos(s(x0))) → COND_EVAL(and(false, true), neg(0), pos(s(x0)))
EVAL(neg(0), neg(0)) → COND_EVAL(and(false, false), neg(0), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, neg(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, neg(0)) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(0), neg(0)) → COND_EVAL(and(false, false), pos(0), neg(0))
EVAL(neg(s(x0)), neg(0)) → COND_EVAL(and(false, false), neg(s(x0)), neg(0))
EVAL(pos(s(x0)), neg(0)) → COND_EVAL(and(true, false), pos(s(x0)), neg(0))
EVAL(neg(0), neg(0)) → COND_EVAL(and(false, false), neg(0), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(0), neg(0)) → COND_EVAL(and(false, false), pos(0), neg(0))
EVAL(neg(s(x0)), neg(0)) → COND_EVAL(and(false, false), neg(s(x0)), neg(0))
EVAL(pos(s(x0)), neg(0)) → COND_EVAL(and(true, false), pos(s(x0)), neg(0))
EVAL(neg(0), neg(0)) → COND_EVAL(and(false, false), neg(0), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1)
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(pos(0), y1) → COND_EVAL(and(false, greater_int(y1, pos(0))), pos(0), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(0), neg(s(x0))) → COND_EVAL(and(false, false), pos(0), neg(s(x0)))
EVAL(pos(0), pos(0)) → COND_EVAL(and(false, false), pos(0), pos(0))
EVAL(pos(0), pos(s(x0))) → COND_EVAL(and(false, true), pos(0), pos(s(x0)))
EVAL(pos(0), neg(0)) → COND_EVAL(and(false, false), pos(0), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(0), neg(s(x0))) → COND_EVAL(and(false, false), pos(0), neg(s(x0)))
EVAL(pos(0), pos(0)) → COND_EVAL(and(false, false), pos(0), pos(0))
EVAL(pos(0), pos(s(x0))) → COND_EVAL(and(false, true), pos(0), pos(s(x0)))
EVAL(pos(0), neg(0)) → COND_EVAL(and(false, false), pos(0), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, pos(0)) → COND_EVAL(and(greater_int(y0, pos(0)), false), y0, pos(0)) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(s(x0)), pos(0)) → COND_EVAL(and(false, false), neg(s(x0)), pos(0))
EVAL(pos(0), pos(0)) → COND_EVAL(and(false, false), pos(0), pos(0))
EVAL(pos(s(x0)), pos(0)) → COND_EVAL(and(true, false), pos(s(x0)), pos(0))
EVAL(neg(0), pos(0)) → COND_EVAL(and(false, false), neg(0), pos(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(neg(s(x0)), pos(0)) → COND_EVAL(and(false, false), neg(s(x0)), pos(0))
EVAL(pos(0), pos(0)) → COND_EVAL(and(false, false), pos(0), pos(0))
EVAL(pos(s(x0)), pos(0)) → COND_EVAL(and(true, false), pos(s(x0)), pos(0))
EVAL(neg(0), pos(0)) → COND_EVAL(and(false, false), neg(0), pos(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, pos(s(x0))) → COND_EVAL(and(greater_int(y0, pos(0)), true), y0, pos(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(0), pos(s(y1))) → COND_EVAL(and(false, true), pos(0), pos(s(y1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(and(true, true), pos(s(x0)), pos(s(y1)))
EVAL(neg(s(x0)), pos(s(y1))) → COND_EVAL(and(false, true), neg(s(x0)), pos(s(y1)))
EVAL(neg(0), pos(s(y1))) → COND_EVAL(and(false, true), neg(0), pos(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(0), pos(s(y1))) → COND_EVAL(and(false, true), pos(0), pos(s(y1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(and(true, true), pos(s(x0)), pos(s(y1)))
EVAL(neg(s(x0)), pos(s(y1))) → COND_EVAL(and(false, true), neg(s(x0)), pos(s(y1)))
EVAL(neg(0), pos(s(y1))) → COND_EVAL(and(false, true), neg(0), pos(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(and(true, true), pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(and(true, true), pos(s(x0)), pos(s(y1))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(pos(s(x0)), y1) → COND_EVAL(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(y0)), pos(0)) → COND_EVAL(and(true, false), pos(s(y0)), pos(0))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL(and(true, true), pos(s(y0)), pos(s(x0)))
EVAL(pos(s(y0)), neg(s(x0))) → COND_EVAL(and(true, false), pos(s(y0)), neg(s(x0)))
EVAL(pos(s(y0)), neg(0)) → COND_EVAL(and(true, false), pos(s(y0)), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(0)) → COND_EVAL(and(true, false), pos(s(y0)), pos(0))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL(and(true, true), pos(s(y0)), pos(s(x0)))
EVAL(pos(s(y0)), neg(s(x0))) → COND_EVAL(and(true, false), pos(s(y0)), neg(s(x0)))
EVAL(pos(s(y0)), neg(0)) → COND_EVAL(and(true, false), pos(s(y0)), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL(and(true, true), pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL(and(true, true), pos(s(y0)), pos(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL(true, pos(s(y0)), pos(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(pos(s(x0)), y1) → COND_EVAL1(and(true, greater_int(y1, pos(0))), pos(s(x0)), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(y0)), neg(0)) → COND_EVAL1(and(true, false), pos(s(y0)), neg(0))
EVAL(pos(s(y0)), neg(s(x0))) → COND_EVAL1(and(true, false), pos(s(y0)), neg(s(x0)))
EVAL(pos(s(y0)), pos(0)) → COND_EVAL1(and(true, false), pos(s(y0)), pos(0))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(and(true, true), pos(s(y0)), pos(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), neg(0)) → COND_EVAL1(and(true, false), pos(s(y0)), neg(0))
EVAL(pos(s(y0)), neg(s(x0))) → COND_EVAL1(and(true, false), pos(s(y0)), neg(s(x0)))
EVAL(pos(s(y0)), pos(0)) → COND_EVAL1(and(true, false), pos(s(y0)), pos(0))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(and(true, true), pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(and(true, true), pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(and(true, true), pos(s(y0)), pos(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(neg(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(0), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(0), pos(s(x0))) → COND_EVAL1(and(false, true), neg(0), pos(s(x0)))
EVAL(neg(0), neg(s(x0))) → COND_EVAL1(and(false, false), neg(0), neg(s(x0)))
EVAL(neg(0), pos(0)) → COND_EVAL1(and(false, false), neg(0), pos(0))
EVAL(neg(0), neg(0)) → COND_EVAL1(and(false, false), neg(0), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(neg(0), pos(s(x0))) → COND_EVAL1(and(false, true), neg(0), pos(s(x0)))
EVAL(neg(0), neg(s(x0))) → COND_EVAL1(and(false, false), neg(0), neg(s(x0)))
EVAL(neg(0), pos(0)) → COND_EVAL1(and(false, false), neg(0), pos(0))
EVAL(neg(0), neg(0)) → COND_EVAL1(and(false, false), neg(0), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, neg(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(0)) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), neg(0)) → COND_EVAL1(and(true, false), pos(s(x0)), neg(0))
EVAL(neg(s(x0)), neg(0)) → COND_EVAL1(and(false, false), neg(s(x0)), neg(0))
EVAL(pos(0), neg(0)) → COND_EVAL1(and(false, false), pos(0), neg(0))
EVAL(neg(0), neg(0)) → COND_EVAL1(and(false, false), neg(0), neg(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(pos(s(x0)), neg(0)) → COND_EVAL1(and(true, false), pos(s(x0)), neg(0))
EVAL(neg(s(x0)), neg(0)) → COND_EVAL1(and(false, false), neg(s(x0)), neg(0))
EVAL(pos(0), neg(0)) → COND_EVAL1(and(false, false), pos(0), neg(0))
EVAL(neg(0), neg(0)) → COND_EVAL1(and(false, false), neg(0), neg(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(pos(0), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), pos(0), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(0), neg(0)) → COND_EVAL1(and(false, false), pos(0), neg(0))
EVAL(pos(0), pos(0)) → COND_EVAL1(and(false, false), pos(0), pos(0))
EVAL(pos(0), pos(s(x0))) → COND_EVAL1(and(false, true), pos(0), pos(s(x0)))
EVAL(pos(0), neg(s(x0))) → COND_EVAL1(and(false, false), pos(0), neg(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(pos(0), neg(0)) → COND_EVAL1(and(false, false), pos(0), neg(0))
EVAL(pos(0), pos(0)) → COND_EVAL1(and(false, false), pos(0), pos(0))
EVAL(pos(0), pos(s(x0))) → COND_EVAL1(and(false, true), pos(0), pos(s(x0)))
EVAL(pos(0), neg(s(x0))) → COND_EVAL1(and(false, false), pos(0), neg(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1)
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(neg(s(x0)), y1) → COND_EVAL1(and(false, greater_int(y1, pos(0))), neg(s(x0)), y1) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(s(y0)), pos(s(x0))) → COND_EVAL1(and(false, true), neg(s(y0)), pos(s(x0)))
EVAL(neg(s(y0)), neg(0)) → COND_EVAL1(and(false, false), neg(s(y0)), neg(0))
EVAL(neg(s(y0)), neg(s(x0))) → COND_EVAL1(and(false, false), neg(s(y0)), neg(s(x0)))
EVAL(neg(s(y0)), pos(0)) → COND_EVAL1(and(false, false), neg(s(y0)), pos(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(neg(s(y0)), pos(s(x0))) → COND_EVAL1(and(false, true), neg(s(y0)), pos(s(x0)))
EVAL(neg(s(y0)), neg(0)) → COND_EVAL1(and(false, false), neg(s(y0)), neg(0))
EVAL(neg(s(y0)), neg(s(x0))) → COND_EVAL1(and(false, false), neg(s(y0)), neg(s(x0)))
EVAL(neg(s(y0)), pos(0)) → COND_EVAL1(and(false, false), neg(s(y0)), pos(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, pos(0)) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, pos(0)) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(0), pos(0)) → COND_EVAL1(and(false, false), neg(0), pos(0))
EVAL(pos(0), pos(0)) → COND_EVAL1(and(false, false), pos(0), pos(0))
EVAL(pos(s(x0)), pos(0)) → COND_EVAL1(and(true, false), pos(s(x0)), pos(0))
EVAL(neg(s(x0)), pos(0)) → COND_EVAL1(and(false, false), neg(s(x0)), pos(0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(neg(0), pos(0)) → COND_EVAL1(and(false, false), neg(0), pos(0))
EVAL(pos(0), pos(0)) → COND_EVAL1(and(false, false), pos(0), pos(0))
EVAL(pos(s(x0)), pos(0)) → COND_EVAL1(and(true, false), pos(s(x0)), pos(0))
EVAL(neg(s(x0)), pos(0)) → COND_EVAL1(and(false, false), neg(s(x0)), pos(0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, neg(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), false), y0, neg(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), neg(s(y1))) → COND_EVAL1(and(true, false), pos(s(x0)), neg(s(y1)))
EVAL(neg(0), neg(s(y1))) → COND_EVAL1(and(false, false), neg(0), neg(s(y1)))
EVAL(neg(s(x0)), neg(s(y1))) → COND_EVAL1(and(false, false), neg(s(x0)), neg(s(y1)))
EVAL(pos(0), neg(s(y1))) → COND_EVAL1(and(false, false), pos(0), neg(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(pos(s(x0)), neg(s(y1))) → COND_EVAL1(and(true, false), pos(s(x0)), neg(s(y1)))
EVAL(neg(0), neg(s(y1))) → COND_EVAL1(and(false, false), neg(0), neg(s(y1)))
EVAL(neg(s(x0)), neg(s(y1))) → COND_EVAL1(and(false, false), neg(s(x0)), neg(s(y1)))
EVAL(pos(0), neg(s(y1))) → COND_EVAL1(and(false, false), pos(0), neg(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, false) → false
and(false, true) → false
and(true, false) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, true) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule EVAL(y0, pos(s(x0))) → COND_EVAL1(and(greater_int(y0, pos(0)), true), y0, pos(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(neg(0), pos(s(y1))) → COND_EVAL1(and(false, true), neg(0), pos(s(y1)))
EVAL(neg(s(x0)), pos(s(y1))) → COND_EVAL1(and(false, true), neg(s(x0)), pos(s(y1)))
EVAL(pos(0), pos(s(y1))) → COND_EVAL1(and(false, true), pos(0), pos(s(y1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
EVAL(neg(0), pos(s(y1))) → COND_EVAL1(and(false, true), neg(0), pos(s(y1)))
EVAL(neg(s(x0)), pos(s(y1))) → COND_EVAL1(and(false, true), neg(s(x0)), pos(s(y1)))
EVAL(pos(0), pos(s(y1))) → COND_EVAL1(and(false, true), pos(0), pos(s(y1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, true) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
and(false, true) → false
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(and(true, true), pos(s(x0)), pos(s(y1))) at position [0] we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL1(true, pos(s(x0)), pos(s(y1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
and(true, true) → true
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
and(false, false)
and(false, true)
and(true, false)
and(true, true)
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
and(false, false)
and(false, true)
and(true, false)
and(true, true)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0]))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_EVAL(true, x[0], y[0]) → EVAL(minus_int(y[0], pos(s(s(0)))), plus_int(pos(s(0)), x[0])) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, y0, pos(x0)) → EVAL(minus_nat(x0, s(s(0))), plus_int(pos(s(0)), y0))
COND_EVAL(true, y0, neg(x0)) → EVAL(neg(plus_nat(x0, s(s(0)))), plus_int(pos(s(0)), y0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
COND_EVAL(true, y0, pos(x0)) → EVAL(minus_nat(x0, s(s(0))), plus_int(pos(s(0)), y0))
COND_EVAL(true, y0, neg(x0)) → EVAL(neg(plus_nat(x0, s(s(0)))), plus_int(pos(s(0)), y0))
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, y0, pos(x0)) → EVAL(minus_nat(x0, s(s(0))), plus_int(pos(s(0)), y0))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_EVAL(true, y0, pos(x0)) → EVAL(minus_nat(x0, s(s(0))), plus_int(pos(s(0)), y0)) at position [1] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1)))
COND_EVAL(true, neg(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), minus_nat(s(0), x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1)))
COND_EVAL(true, neg(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), minus_nat(s(0), x1))
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(plus_nat(s(0), x1))) at position [1,0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(plus_nat(0, x1))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(plus_nat(0, x1))))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(plus_nat(0, x1)))) at position [1,0,0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1])
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_EVAL1(true, x[1], y[1]) → EVAL(minus_int(x[1], pos(s(0))), x[1]) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
COND_EVAL1(true, neg(x0), y1) → EVAL(neg(plus_nat(x0, s(0))), neg(x0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
COND_EVAL1(true, neg(x0), y1) → EVAL(neg(plus_nat(x0, s(0))), neg(x0))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1)))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_EVAL(true, pos(x1), pos(y1)) → EVAL(minus_nat(y1, s(s(0))), pos(s(x1))) we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z1), s(s(0))), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z1), s(s(0))), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z1), s(s(0))), pos(s(s(z0)))) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_EVAL1(true, pos(x0), y1) → EVAL(minus_nat(x0, s(0)), pos(x0)) we obtained the following new rules [LPAR04]:
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z0), s(0)), pos(s(z0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z0), s(0)), pos(s(z0)))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(s(z0), s(0)), pos(s(z0))) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z0, 0), pos(s(z0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z0, 0), pos(s(z0)))
The TRS R consists of the following rules:
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented rules of the TRS R:
minus_nat(0, s(y)) → neg(s(y))
Used ordering: Polynomial interpretation [POLO]:
POL(0) = 0
POL(COND_EVAL(x1, x2, x3)) = 2·x1 + 2·x2 + x3
POL(COND_EVAL1(x1, x2, x3)) = x1 + 2·x2 + x3
POL(EVAL(x1, x2)) = 2·x1 + x2
POL(minus_nat(x1, x2)) = 1 + 2·x1 + 2·x2
POL(neg(x1)) = x1
POL(pos(x1)) = 1 + 2·x1
POL(s(x1)) = 2·x1
POL(true) = 0
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z0, 0), pos(s(z0)))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
COND_EVAL1(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z0, 0), pos(s(z0)))
The remaining pairs can at least be oriented weakly.
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
Used ordering: Matrix interpretation [MATRO]:
| POL(EVAL(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(COND_EVAL(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(COND_EVAL1(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(minus_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
The following usable rules [FROCOS05] were oriented:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
minus_nat(0, 0) → pos(0)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
EVAL(pos(s(y0)), pos(s(x0))) → COND_EVAL1(true, pos(s(y0)), pos(s(x0)))
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1)))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule EVAL(pos(s(x0)), pos(s(y1))) → COND_EVAL(true, pos(s(x0)), pos(s(y1))) we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0))))
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_EVAL(true, pos(s(z0)), pos(s(z1))) → EVAL(minus_nat(z1, s(0)), pos(s(s(z0)))) we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(s(z1), s(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(s(z1), s(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(s(z1), s(0)), pos(s(s(z0)))) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(z1, 0), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(z1, 0), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(z1, 0), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_EVAL(true, pos(s(z0)), pos(s(s(z1)))) → EVAL(minus_nat(z1, 0), pos(s(s(z0)))) at position [0] we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
COND_EVAL(true, pos(s(y0)), pos(s(s(0)))) → EVAL(pos(0), pos(s(s(y0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
COND_EVAL(true, pos(s(y0)), pos(s(s(0)))) → EVAL(pos(0), pos(s(s(y0))))
The TRS R consists of the following rules:
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
The TRS R consists of the following rules:
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
R is empty.
The set Q consists of the following terms:
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ ForwardInstantiation
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0))))
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [JAR06] the rule EVAL(pos(s(x0)), pos(s(s(z0)))) → COND_EVAL(true, pos(s(x0)), pos(s(s(z0)))) we obtained the following new rules [LPAR04]:
EVAL(pos(s(x0)), pos(s(s(s(y_1))))) → COND_EVAL(true, pos(s(x0)), pos(s(s(s(y_1)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ ForwardInstantiation
↳ QDP
↳ ForwardInstantiation
Q DP problem:
The TRS P consists of the following rules:
COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0))))
EVAL(pos(s(x0)), pos(s(s(s(y_1))))) → COND_EVAL(true, pos(s(x0)), pos(s(s(s(y_1)))))
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [JAR06] the rule COND_EVAL(true, pos(s(y0)), pos(s(s(s(x0))))) → EVAL(pos(s(x0)), pos(s(s(y0)))) we obtained the following new rules [LPAR04]:
COND_EVAL(true, pos(s(s(y_1))), pos(s(s(s(x1))))) → EVAL(pos(s(x1)), pos(s(s(s(y_1)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ ForwardInstantiation
↳ QDP
↳ ForwardInstantiation
↳ QDP
↳ MRRProof
Q DP problem:
The TRS P consists of the following rules:
EVAL(pos(s(x0)), pos(s(s(s(y_1))))) → COND_EVAL(true, pos(s(x0)), pos(s(s(s(y_1)))))
COND_EVAL(true, pos(s(s(y_1))), pos(s(s(s(x1))))) → EVAL(pos(s(x1)), pos(s(s(s(y_1)))))
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:
EVAL(pos(s(x0)), pos(s(s(s(y_1))))) → COND_EVAL(true, pos(s(x0)), pos(s(s(s(y_1)))))
COND_EVAL(true, pos(s(s(y_1))), pos(s(s(s(x1))))) → EVAL(pos(s(x1)), pos(s(s(s(y_1)))))
Used ordering: Polynomial interpretation [POLO]:
POL(COND_EVAL(x1, x2, x3)) = x1 + x2 + x3
POL(EVAL(x1, x2)) = 1 + x1 + x2
POL(pos(x1)) = x1
POL(s(x1)) = 2 + x1
POL(true) = 0
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ MRRProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ ForwardInstantiation
↳ QDP
↳ ForwardInstantiation
↳ QDP
↳ MRRProof
↳ QDP
↳ PisEmptyProof
Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.